import pyshark , binascii , re , base64  , chardet 

from PySide6.QtGui import QGuiApplication
from PIL import Image
from urllib import parse
from FlowAnalyzer import FlowAnalyzer
from tools import config , misc , others
from tools.jiaoben.Behinder import *
from tools.jiaoben.Godzilla import *
from tools.jiaoben import 蚁剑

def 字符串搜索(self):  # 完成
    self.ui.str_search_but.setEnabled(False)
    字符串 = self.ui.input_echo.toPlainText()
    if 字符串 != '':
        正则 = []
        正则.append(字符串)
        正则.append(字符串+"{.*}")
        正则.append(base64.b64encode(字符串.encode()).decode()[0:4]+"[a-zA-Z0-9=]+")
        正则.append("[0-9a-fA-F]+"+binascii.hexlify(字符串.encode()).decode()[1:]+"[0-9a-fA-F]+")
        正则.append('&#[0-9].+;')
        self.ui.print_echo.append(f"正则表达式已设置为 : {'、'.join(正则)}")
        QGuiApplication.processEvents()
    else:
        self.ui.print_echo.append("要搜索的字符串.默认为 flag 会自动编码测试 base64 , hex 等进行搜索")
        正则 = ['flag-.*','flag{.*}','Zmxh','&#[0-9].+;','[0-9a-fA-F]+66c6167[0-9a-fA-F]+']
        self.ui.print_echo.append(f"正则表达式已设置为 : {'、'.join(正则)}")
        QGuiApplication.processEvents()
    if config.file_name :
        with pyshark.FileCapture(config.file_name) as 流量数据: # 
            可打印字符 = set()
            for 流量帧 in 流量数据 :
                for j in 正则:
                    matches = re.findall(j, str(流量帧), re.IGNORECASE)
                    可打印字符.update(matches)
                    try:
                        if 流量帧.DATA.data:
                            decoded_data = binascii.unhexlify(流量帧.DATA.data).decode('utf-8', 'ignore')
                            matches = re.findall(j, decoded_data, re.IGNORECASE)
                            可打印字符.update(matches)
                    except :pass
        if 可打印字符:
            self.ui.print_echo.append('流量中存在以下可打印字符:')
            for i in 可打印字符:
                self.ui.print_echo.append(i)
                QGuiApplication.processEvents()
        else: 
            self.ui.print_echo.append('未找到可打印的字符')
    else:self.ui.print_echo.append('请先选择流量包')
    self.ui.str_search_but.setEnabled(True)
    self.ui.print_echo.append('搜索字符串完成')
    
def 提取日志(self):
    流量数据= pyshark.FileCapture(config.file_name, display_filter='http.request')  # 读取流量包
    self.ui.print_echo.append('开始提取日志')
    QGuiApplication.processEvents()
    流量包= []
    for 流量帧 in 流量数据:
        if 流量帧.http:  # 确保http属性存在
            流量包.append(f'源IP:{流量帧.ip.src},目标IP:{流量帧.ip.dst},URL:{流量帧.http.request_full_uri}')
        else:
            流量包.append(流量帧)
    with open(f'{config.文件目录}/流量数据包.txt','w+',encoding='utf-8') as f:
        for 数据帧 in 流量包:
            f.write(parse.unquote(数据帧)+'\n')
    self.ui.print_echo.append(f'流量日志已保存至:{config.文件目录}/流量数据包.txt')
         
def TTL分析(self):
    try:
        流量数据= pyshark.FileCapture(config.file_name, display_filter='icmp')  # 读取流量包
    except:
        self.ui.print_echo.append('流量数据提取错误')
    ttl=[]
    for 流量帧 in 流量数据:
        ttl.append(int(流量帧.ip.ttl))
    self.ui.print_echo.append(str(ttl))
    with open(config.文件目录 + "/ttl流量.txt", "w") as f:
        f.write(str(ttl))
    
def len长度分析(self): # len隐藏分析
    流量数据= pyshark.FileCapture(config.file_name, display_filter="icmp && icmp.type==8")  # 读取流量包
    con1 = ""
    con2 = ""
    for i in range(0, len(流量数据)):
        if 流量数据[i].icmp.data_len == '32':
            con1 += '0'
            con2 += '1'
        elif 流量数据[i].icmp.data_len == '64':
            con1 += '1'
            con2 += '0'
    self.ui.print_echo.append(con1)
    self.ui.print_echo.append(con2)

def 文件提取(self,流量):
    if '1f8b08' in 流量.hex():
        self.ui.print_echo.append('发现压缩包,正在提取:')
        文件 = re.findall(r'1f8b08.+', 流量.hex() , re.I)
        try:
            with open(config.文件目录+'\提取的流量.tar.gz', 'wb+') as f:
                f.write(binascii.unhexlify(文件[0]))
            self.ui.print_echo.append('压缩包提取完成,请查看'+config.文件目录+'\提取的流量.tar.gz"')
        except:self.ui.print_echo.append('压缩包提取失败')
    if '504B0304' in 流量.hex():
        self.ui.print_echo.append('发现压缩包,正在提取:')
        文件 = re.findall(r'504B0304.+', 流量.hex() , re.I)    
        try:
            with open(config.文件目录+'\提取的流量.zip', 'wb+') as f:
                f.write(binascii.unhexlify(文件[0]))
            self.ui.print_echo.append('压缩包提取完成,请查看'+config.文件目录+'\提取的流量.zip"')
        except:self.ui.print_echo.append('压缩包提取失败')

class 注入分析:
    def 注入分析(self):
        self.ui.print_echo.clear()
        self.ui.print_echo.append('开始分析流量包')
        QGuiApplication.processEvents()
        注入语句列表 = 注入分析.流量读取(self)
        注入分析.流量分析(self, 注入语句列表)

    def 流量读取(self):
        try:
            jsonpath = FlowAnalyzer.get_json_data(config.file_name,display_filter='http.request.method == GET or http.request.method == POST or http.response.code')
            注入语句列表 = []
            网址 = []
            for count, http in enumerate(FlowAnalyzer(jsonpath).generate_http_dict_pairs(), start=1):
                if 'select' in http.request.file_data.decode().lower():   # post请求
                    网址 = parse.unquote(http.request.file_data.decode())
                    注入语句列表.append(网址)
                elif 'select'  in http.request.full_uri.lower():  # get请求
                    网址.append(parse.unquote(http.request.full_uri))
                    if self.ui.check_sql.isChecked() == True :
                        if '404' in http.response.header.decode():
                            注入语句列表.append(网址[-1])
                    else:
                        注入语句列表.append(网址[-1])
            QGuiApplication.processEvents()
            return 注入语句列表
        except:
            self.ui.print_echo.append('流量数据读取错误，请检查文件输入')
            raise
        
    def 流量分析(self,注入语句列表):
        flag_字典 = {}
        注入语句字典 ={}
        for 注入语句 in 注入语句列表:
            if 'user' in 注入语句 :
                用户名 = re.findall(r'user\s+([0-9a-z_]+)',注入语句,re.I)[-1]
                self.ui.print_echo.append(用户名)
            if 'database' in 注入语句 :
                数据库名 = re.findall(r'database\s+([0-9a-z_]+)',注入语句,re.I)[-1]
                self.ui.print_echo.append(数据库名)
            if re.search('union.+',注入语句,re.I) :  # union注入
                # self.ui.print_echo.append(re.search('union.+',注入语句,re.I)[0])
                pass
            if re.search('select.+',注入语句,re.I) :  # select注入
                if re.findall(r'([0-9 ]+,[0-9 ]+)[)=><]+([0-9]+)',注入语句,re.I) != []:
                    注入 = re.search('select.+',注入语句,re.I)[0]
                    if re.sub(r'([0-9 ]+,[0-9 ]+)[)=><]+([0-9]+)','',注入) in 注入语句字典:
                        pass
                    else:
                        flag_字典={}
                    flag_字段=re.findall(r'([0-9 ]+,[0-9 ]+)[)=><]+([0-9]+)',注入)[-1]
                    flag_字典[flag_字段[0]] = chr(int(flag_字段[1]))
                    注入语句字典[re.sub(r'([0-9 ]+,[0-9 ]+)[)=><]+([0-9]+)','',注入)] = ''.join(list(flag_字典.values()))
        for 语句 , 值 in 注入语句字典.items():
            self.ui.print_echo.append(f'语句为:\n{语句}\n值为:{str(值)}\n')
        self.ui.print_echo.append('流量分析结束')
       
class USB流量分析:    # 基本完成
    def USB流量分析(self):
        self.ui.usb_but.setEnabled(False)
        键盘数据包 = []
        鼠标数据包 = []
        self.ui.print_echo.append("正在提取USB流量")
        QGuiApplication.processEvents()
        try:
            流量数据= pyshark.FileCapture(config.file_name, display_filter='usb')  # 读取流量包
        except:
            self.ui.print_echo.append("请选择正确的流量包")
            QGuiApplication.processEvents()
        for 流量帧 in 流量数据:  # 获取每个流量帧
            try:
                try:
                    if 流量帧.DATA.usb_capdata:
                        键盘数据包.append(''.join(流量帧.DATA.usb_capdata.split(':'))) # 获取usb键盘数据,并拼接为字符串,并加入数据列表
                except:
                    if 流量帧.DATA.usbhid_data:
                        if len(''.join(流量帧.DATA.usbhid_data.split(':'))) != 8:
                            鼠标数据包.append(''.join(流量帧.DATA.usbhid_data.split(':')[1:5]))
                        else:
                            鼠标数据包.append(''.join(流量帧.DATA.usbhid_data.split(':'))) # 获取usb鼠标数据,并拼接为字符串,并加入数据列表
            except:
                pass
        if 键盘数据包:
            with open(f'{config.文件目录}/USB键盘流量数据包.txt','w+',encoding="utf-8") as f:
                for 数据帧 in 键盘数据包:
                    f.write(数据帧+'\n')
            self.ui.print_echo.append(f"USB键盘流量数据已保存至 : {config.文件目录}/USB键盘流量数据包.txt " )
            QGuiApplication.processEvents()
            try:
                self.ui.print_echo.append('准备解析键盘流量')
                QGuiApplication.processEvents()
                USB流量分析.usb数据解析(self,键盘数据包,16)
            except:
                self.ui.print_echo.append('键盘流量解析错误')
        if 鼠标数据包:
            with open(f'{config.文件目录}/USB鼠标流量数据包.txt','w+',encoding="utf-8") as f:
                for 数据帧 in 鼠标数据包:
                    f.write(数据帧+'\n')
            self.ui.print_echo.append(f"USB鼠标流量数据已保存至 : {config.文件目录}/USB鼠标流量数据包.txt " )
            QGuiApplication.processEvents()
            try:
                self.ui.print_echo.append('准备解析鼠标流量')
                QGuiApplication.processEvents()
                USB流量分析.usb数据解析(self,鼠标数据包,8)
            except:self.ui.print_echo.append('鼠标流量解析错误')
        self.ui.usb_but.setEnabled(True)

    def usb数据解析(self,数据包,k):
        try:
            usb_data = ""
            for j in 数据包:
                if len(j) == k:  # 键盘流量的话len为16 鼠标为8
                    out = ""
                    for i in range(0, len(j), 2):
                        if i + 2 != len(j):
                            out += j[i] + j[i + 1] + ":"
                        else:
                            out += j[i] + j[i + 1]
                    usb_data += out
                    usb_data += "\n"
        except:
            self.ui.print_echo.append("usb数据解析错误")
            QGuiApplication.processEvents()
        if k == 8:
            try:    
                self.ui.print_echo.append('开始分析鼠标数据')
                QGuiApplication.processEvents()
                Left = " "
                right = " "
                posx = 0
                posy = 0
                for line in usb_data.split("\n"):
                    if len(line) != 11:
                        continue
                    x = int(line[3:5], 16)
                    y = int(line[6:8], 16)
                    if x > 127:
                        x -= 256
                    if y > 127:
                        y -= 256
                    posx += x
                    posy += y
                    btn_flag = int(line[0:2], 16)  # 0为不按键 1为左 2为右
                    if btn_flag == 1:  # 此处的0可以修改为0(未按按键)、1(左键)、2(右键)，将单独输出相应坐标文件。
                        Left += str(posx)
                        Left += " "
                        Left += str(posy)
                        Left += "\n"
                    elif btn_flag == 2:
                        right += str(posx)
                        right += " "
                        right += str(posy)
                        right += "\n"
                #self.ui.print_echo.append(Left)
                #self.ui.print_echo.append(right)
                if Left!= " ":
                    self.ui.print_echo.append("正在生成鼠标左键图，请稍后")
                    QGuiApplication.processEvents()
                    USB流量分析.制图(self,Left,'左键图')
                if right != " ":
                    self.ui.print_echo.append("正在生成鼠标右键图，请稍后")
                    QGuiApplication.processEvents()
                    USB流量分析.制图(self,right,'右键图')
            except:
                self.ui.print_echo.append("鼠标数据分析错误")
                QGuiApplication.processEvents()
        elif k == 16:
            self.ui.print_echo.append('开始分析键盘数据')
            QGuiApplication.processEvents()
            键盘记录 = ''
            mappings = {0x04:"A", 0x05:"B",  0x06:"C",  0x07:"D",  0x08:"E", 0x09:"F", 0x0A:"G", 0x0B:"H", 0x0C:"I", 
                        0x0D:"J", 0x0E:"K",  0x0F:"L",  0x10:"M",  0x11:"N", 0x12:"O", 0x13:"P", 0x14:"Q", 0x15:"R", 
                        0x16:"S", 0x17:"T",  0x18:"U",  0x19:"V",  0x1A:"W", 0x1B:"X", 0x1C:"Y", 0x1D:"Z", 0x1E:"1", 
                        0x1F:"2", 0x20:"3",  0x21:"4",  0x22:"5",  0x23:"6", 0x24:"7", 0x25:"8", 0x26:"9", 0x27:"0", 
                        0X2C:" ", 0x2d:"-",  0x2E:"=",  0x2F:"[",  0x30:"]", 0x32:"~", 0x33:";", 0x34:"`", 0x36:",",
                        0x37:".", 0x28:"\n", 0x2B:"\t", 0x31:"\\", 0x82:"[casps LOCK]",  0x2A:"[DEL]"}
            try:
                for key in usb_data.split('\n'):
                    if key:
                        if key.split(":")[2] != "00" or key.split(":")[2] != "":
                            strs = str(key.split(":")[2])
                            id = "0x"+strs
                            if int(id,16) in mappings:
                                键盘记录 += mappings[int(id,16)]
                self.ui.print_echo.append("键盘输出的键为："+键盘记录)
            except:
                self.ui.print_echo.append("键盘数据解析错误")
            self.ui.print_echo.append(键盘记录)

    def 制图(self,坐标,名称):
        try:
            img = Image.new("RGB", (2000, 2000), (255, 255, 255))  # 创建Image对象
            for i in range(len(坐标.split("\n")) - 1):
                line = 坐标.split("\n")[i]
                point = line.split()
                img.putpixel((int(point[0]), int(point[1])), (0, 0, 0))
            img.show()
            img.save(config.文件目录 + f"/{名称}.png")
            self.ui.print_echo.append("分析完成")
        except:
            self.ui.print_echo.append("制图错误")

def 搜索密钥(self):  # 搜索key待优化
    key = []
    self.ui.print_echo.clear()
    jsonpath = FlowAnalyzer.get_json_data(config.file_name,display_filter='http.response.code == 200')
    for count, http in enumerate(FlowAnalyzer(jsonpath).generate_http_dict_pairs(), start=1):
        try:
            if http.response.file_data:
                if len(http.response.file_data.decode()) == 16:
                    key.append(http.response.file_data.decode())
                print(http.response.file_data.decode())
                if re.findall(r'[0-9a-zA-Z]*=([0-9a-zA-Z]*)"',http.response.file_data.decode(),re.DOTALL)[-1] != '':
                    key.append(re.findall(r'[0-9a-zA-Z]*=([0-9a-zA-Z]*)"',http.response.file_data.decode(),re.DOTALL)[0])  # xc="3c6e0b8a9c15224a"
        except:pass
    if key != []:
        for i in key:
            if len(i) == 16:
                self.ui.print_echo.append(f'已发现key为 : {i}')

    self.ui.print_echo.append('搜索key完毕')

def 单条解密按钮(self):
    shell_name = self.ui.shell_name.currentText()
    字符串 = self.ui.input_echo.toPlainText()
    if self.ui.checkBox_req.isChecked() == True:
        类型 = self.ui.checkBox_req.text()
    elif self.ui.checkBox_res.isChecked() == True:
        类型 = self.ui.checkBox_res.text()
    if shell_name == '菜刀':
        菜刀流量分析.单条解密(self,字符串)
    elif shell_name == '蚁剑':
        self.ui.checkBox_res.setChecked(False) 
        蚁剑流量分析.单条解密(self)
    elif shell_name == '哥斯拉':
        哥斯拉流量分析.单条解密(self,字符串,类型)
    elif shell_name == '冰蝎':
        冰蝎流量分析.单条解密(self,字符串,类型)

def 自动解密按钮(self):
    shell_name = self.ui.shell_name.currentText()
    if shell_name == '菜刀':
        菜刀流量分析.批量解密(self)
    elif shell_name == '蚁剑':
        蚁剑流量分析.批量解密(self)
    elif shell_name == '哥斯拉':
        哥斯拉流量分析.批量解密(self)
    elif shell_name == '冰蝎':
        冰蝎流量分析.批量解密(self)

def shell数据读取(self):
    shell_name = self.ui.shell_name.currentText()
    shell_type = self.ui.shell_type.currentText()
    shell_maner = self.ui.shell_maner.currentText()
    return shell_name , shell_type ,shell_maner
    
class 哥斯拉流量分析: # 基本完成，搜索key待优化    
    def 批量解密(self):   
        self.ui.print_echo.clear()
        #jsonpath = FlowAnalyzer.get_json_data(config.file_name,display_filter='tcp and http.request or http.response.code == 200')
        jsonpath = FlowAnalyzer.get_json_data(config.file_name,display_filter='http.request.method == POST or http.response.code == 200')
        for count, http in enumerate(FlowAnalyzer(jsonpath).generate_http_dict_pairs(), start=1):
            request, response = http.request, http.response
            try:
                if self.ui.checkBox_req.isChecked() == True:  # 判断是否选中请求
                    哥斯拉流量分析.单条解密(self,request.file_data,'请求')
                if self.ui.checkBox_res.isChecked() == True:  # 判断是否选中响应
                    哥斯拉流量分析.单条解密(self,response.file_data,'响应')
            except:pass
            QGuiApplication.processEvents()
            
    def 单条解密(self,字符串,类型):
        key = self.ui.key_link.text()
        if key == '':
            key = '3c6e0b8a9c15224a'
        pass_ = self.ui.pass_link.text()
        if pass_ == '':  
            pass_ = 'pass'
        shell_name , shell_type , shell_maner = shell数据读取(self)
        命令=(f'{shell_maner}(pass_="{pass_}",key="{key}")') 
        decrypter = eval(命令)  # 实例化PHP类
        if 类型 == '请求':
            if shell_maner in ['PHP_XOR_RAW','JAVA_AES_RAW','ASP_XOR_RAW','CSHAP_AES_RAW']:
                try:
                    try:
                        binascii.unhexlify(字符串)
                        字符串 = 字符串
                    except:字符串= 字符串.hex()
                    data = decrypter.decrypt_req_payload(bytes(bytearray.fromhex(字符串)))
                except:self.ui.print_echo.append(f'{shell_maner}解密失败\n')
            else:
                try:
                    data = decrypter.decrypt_req_payload(字符串)
                except:self.ui.print_echo.append(f'{shell_maner}解密失败\n')
            self.ui.print_echo.append(f'请求为:\n{data.decode(errors="ignore")}')
        if 类型 == '响应':
            if shell_maner in ['PHP_XOR_RAW','JAVA_AES_RAW','ASP_XOR_RAW','CSHAP_AES_RAW']:
                try:
                    try:
                        binascii.unhexlify(字符串)
                        字符串 = 字符串
                    except:字符串= 字符串.hex()
                    data = decrypter.decrypt_res_payload(bytes(bytearray.fromhex(字符串)))
                except:self.ui.print_echo.append(f'{shell_maner}解密失败\n')
            else:
                try:
                    data = decrypter.decrypt_res_payload(字符串)
                except:self.ui.print_echo.append(f'{shell_maner}解密失败\n')
            self.ui.print_echo.append(f'响应为:\n{data.decode(errors="ignore")}')

class 冰蝎流量分析:  # 基本完成，搜索key待优化
    def 单条解密(self,字符串,类型):
        # self.ui.print_echo.clear()
        key = self.ui.key_link.text()
        if key == '':
            key = 'e45e329feb5d925b' # 这里是默认密码 rebeyond key值为密码的md5值前16位
        shell_name , shell_type , shell_maner = shell数据读取(self)
        命令=(f'{shell_maner}(key="{key}")')
        decrypter = eval(命令)
        try:
            if shell_maner in ['ASP','ASPX']:
                字符串 = base64.b64decode(字符串.encode())
            if shell_maner == 'JAVA':
                if 类型 == '响应':  
                    字符串 = base64.b64decode(字符串.encode())
            if 类型 == '请求':
                req_data = decrypter.decrypt_req_payload(字符串)
                req_data = req_data.decode(chardet.detect(req_data)['encoding']) # 检查编码
                #self.ui.print_echo.append(f'请求内容为:\n{req_data}')
                冰蝎流量分析.内容读取(self,req_data)
            elif 类型 == '响应':
                res_data = decrypter.decrypt_res_payload(字符串)
                res_data = res_data.decode(chardet.detect(res_data)['encoding'])
                self.ui.print_echo.append(f'响应内容为:\n{res_data}')
                冰蝎流量分析.内容读取(self,res_data)
        except:self.ui.print_echo.append('解密错误')

    def 内容读取(self,字符串):
        if re.findall('mode=.+',字符串)[0] != '':
            命令 = re.findall('mode=.+',字符串)[0]
        self.ui.print_echo.append(f'命令为:\n{命令}')
        

    def 批量解密(self):
        self.ui.print_echo.clear()
        jsonpath = FlowAnalyzer.get_json_data(config.file_name,display_filter='http.request.method == POST or  http.response.code ==200')
        for count, http in enumerate(FlowAnalyzer(jsonpath).generate_http_dict_pairs(), start=1):
            if self.ui.checkBox_req.isChecked() == True:
                if http.request:
                    file_data = http.request.file_data.decode()
                    try:
                        if '<' in file_data:
                            pass
                        elif '\n' in file_data:
                            pass
                        else:
                            self.ui.print_echo.append(f"[+] 正在处理第{count}个HTTP流!")
                            冰蝎流量分析.单条解密(self,file_data,'请求')
                            QGuiApplication.processEvents()  
                    except:
                        pass
            if self.ui.checkBox_res.isChecked() == True:
                if http.response:
                    file_data = http.response.file_data.decode()
                    try:
                        if '<' in file_data:
                            pass
                        elif '\n' in file_data:
                            pass
                        else:
                            self.ui.print_echo.append(f"[+] 正在处理第{count}个HTTP流!")
                            冰蝎流量分析.单条解密(self,file_data,'响应')
                            QGuiApplication.processEvents()   
                    except:
                        pass
        self.ui.print_echo.append('自动解密完成')
        print('自动解密执行完毕')
            
class 菜刀流量分析():  # 完成40%
    def 批量解密(self):
        jsonpath = FlowAnalyzer.get_json_data(config.file_name,display_filter='http.request or http.response')
        for count, http in enumerate(FlowAnalyzer(jsonpath).generate_http_dict_pairs(), start=1):
            request, response = http.request, http.response
            self.ui.print_echo.append(f'正在处理第{count}个HTTP流!')
            if request.file_data:
                菜刀流量分析.单条解密(self,http.request.file_data.decode())
                文件提取(self,http.response.file_data)
            if response.file_data:
                try:
                    菜刀流量分析.单条解密(self,http.response.file_data.decode(errors= 'ignore'))
                    文件提取(self,http.response.file_data)
                except:
                    菜刀流量分析.单条解密(self,http.response.file_data)
    def 单条解密(self,字符串):
        try:
            if 'array_map("ass"."ert",array' in 字符串:  # 判断是否是菜刀流量
                self.ui.print_echo.append('发现菜刀流量:')
                字符串 = parse.unquote(字符串)
                主语句 = re.findall(r'.([A-Za-z0-9=/+]*).', 字符串 , re.I)
                try:
                    主语句解码 = base64.b64decode(max(主语句, key=len)).decode()
                    self.ui.print_echo.append(f'菜刀命令:"\n"{主语句解码}')
                except:pass
            elif 'base64_decode' in 字符串:
                self.ui.print_echo.append('发现菜刀流量:')
                字符串 = parse.unquote(字符串)
                主语句 = re.findall(r'=([a-z0-9A-Z+=]*)', 字符串 , re.I)
                try:
                    for i in 主语句:
                        self.ui.print_echo.append(f'菜刀命令:"\n"{base64.b64decode(i).decode()}')
                except:pass
            else:
                if 'X@Y' and '->|' in 字符串 :
                    self.ui.print_echo.append('返回的结果:')
                    返回值 = 字符串.split('\n')
                    for i in 返回值:self.ui.print_echo.append(i)
        except:
            self.ui.print_echo.append('菜刀流量解析错误')

class 蚁剑流量分析():  # 未完成
    请求命令 = ''

    def 单条解密(self):
        shell_maner = self.ui.shell_maner.currentText()
        if shell_maner == 'PHP':
            字符串 =self.ui.input_echo.toPlainText()
            解码字符串 = parse.unquote(字符串)
            self.ui.print_echo.append(f'请求命令:\n{解码字符串}')
            QGuiApplication.processEvents() 
        elif shell_maner == 'PHP_RSA':
            if self.ui.checkBox_req.isChecked() == True:
                请求字符串 = self.ui.input_echo.toPlainText()
                if 请求字符串 == '':
                    self.ui.print_echo.append('请先输入请求')
                    raise
                pem = config.str1
                if pem == '':
                    self.ui.print_echo.append('请在变量1中设置公钥文件路径')
                    raise
                请求命令 = 蚁剑.PHP.PHP_RSA_req(请求字符串 , pem)
                self.ui.print_echo.append(f'请求命令: \n{请求命令}')
            
    def 批量解密(self):
        shell_maner = self.ui.shell_maner.currentText()
        jsonpath = FlowAnalyzer.get_json_data(config.file_name,display_filter='http.request.method == POST or http.response.code == 200')
        for count, http in enumerate(FlowAnalyzer(jsonpath).generate_http_dict_pairs(), start=1):
            request, response = http.request, http.response
            try:
                if shell_maner == 'PHP':
                    蚁剑流量分析.单条解密(self,request.file_data.decode())
                if shell_maner == 'PHP_RSA':
                    if request.file_data.decode():
                        pem = config.str1
                        if pem == '':
                            self.ui.print_echo.append('请在变量1中设置公钥文件路径')
                            raise
                        请求命令 = 蚁剑.PHP.PHP_RSA_req(request.file_data.decode(),pem)
                        self.ui.print_echo.append(f'请求命令: \n{请求命令}\n')
                    QGuiApplication.processEvents()
                    if response.file_data.decode():
                        key = self.ui.key_link.text().encode()
                        if key == '':
                            self.ui.print_echo.append('请在key中输入解密密钥')
                            raise
                        响应内容 = 蚁剑.PHP.PHP_RSA_res(请求命令 , response.file_data.decode(), key)
                        self.ui.print_echo.append(f'响应为:\n{响应内容}\n')
                    QGuiApplication.processEvents()

                    #print(response.file_data.decode())
                    #内容 = re.findall(f'{前缀}(.+){后缀}', response.file_data.decode(),re.DOTALL)
                    #self.ui.print_echo.append(f'响应为:{内容[-1]}')
                    QGuiApplication.processEvents() 
            except:pass
            







''' 可以执行并提取，但是这个需求貌似不对，暂时注释掉

def 流量提取(self):
    self.ui.tiqu_but.setEnabled(False)
    过滤器 = self.ui.input_echo.toPlainText()
    if 过滤器 == '':
        过滤器 = 'http and http.request'
    try:
        流量数据= pyshark.FileCapture(config.file_name, display_filter=f'{过滤器}')  # 读取流量包
    except:
        self.ui.print_echo.append('流量数据提取错误')
    try:
        with open(config.文件目录+'\提取的流量.txt', 'w') as 文件:
            for 数据帧 in 流量数据:
                文件.write(数据帧.http.request_full_uri +'\n')
    except:
        self.ui.print_echo.append('流量数据写入错误')
    self.ui.tiqu_but.setEnabled(True)
    self.ui.print_echo.append(f'流量数据提取完成，请查看{config.文件目录}/提取的流量.txt"')

'''